import mysql from 'mysql2';
import config from './config.js';

// 创建数据库连接池
const pool = mysql.createPool(config.database);

// 将连接池转换为promise
const poolPromise = pool.promise();

// 封装查询函数
const query = async (sql, params) => {
  try {
    // 在每次查询前确保选择了正确的数据库
    if (!sql.toLowerCase().includes('use ') && !sql.toLowerCase().includes('create database')) {
      await poolPromise.query(`USE ${config.databaseName}`);
    }
    
    const [rows] = await poolPromise.query(sql, params);
    return rows;
  } catch (error) {
    console.error('数据库查询错误:', error);
    throw error;
  }
};

// 初始化数据库和表
const initDatabase = async () => {
  try {
    console.log("正在连接到MySQL并初始化数据库...");
    
    // 检查数据库是否存在，不存在则创建
    await query(`CREATE DATABASE IF NOT EXISTS ${config.databaseName}`);
    console.log(`数据库 ${config.databaseName} 检查/创建成功`);
    
    // 使用创建的数据库
    await query(`USE ${config.databaseName}`);
    console.log(`切换到数据库 ${config.databaseName} 成功`);
    
    // 创建用户表
    const createUserTable = `
      CREATE TABLE IF NOT EXISTS users (
        id INT PRIMARY KEY AUTO_INCREMENT,
        username VARCHAR(50) NOT NULL,
        email VARCHAR(100) NOT NULL UNIQUE,
        password VARCHAR(100) NOT NULL,
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
      )
    `;
    
    await query(createUserTable);
    console.log('用户表初始化成功');
    
    // 创建智能体表
    const createAgentsTable = `
      CREATE TABLE IF NOT EXISTS agents (
        id VARCHAR(50) PRIMARY KEY,
        user_id INT NOT NULL,
        name VARCHAR(50) NOT NULL,
        description TEXT,
        system_prompt TEXT,
        icon VARCHAR(50),
        color VARCHAR(100),
        tags JSON,
        category VARCHAR(50),
        is_custom BOOLEAN DEFAULT TRUE,
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
        FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
      )
    `;
    
    await query(createAgentsTable);
    console.log('智能体表初始化成功');
    
    // 创建智能体收藏表
    const createFavoritesTable = `
      CREATE TABLE IF NOT EXISTS favorite_agents (
        id INT PRIMARY KEY AUTO_INCREMENT,
        user_id INT NOT NULL,
        agent_id VARCHAR(50) NOT NULL,
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
        UNIQUE KEY unique_favorite (user_id, agent_id),
        FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
      )
    `;
    
    await query(createFavoritesTable);
    console.log('智能体收藏表初始化成功');
  } catch (error) {
    console.error('数据库初始化失败:', error);
    throw error; // 重新抛出错误以便上层处理
  }
};

// 更新用户名
const updateUsername = async (userId, newUsername) => {
  try {
    const sql = `UPDATE users SET username = ? WHERE id = ?`;
    const result = await query(sql, [newUsername, userId]);
    return result.affectedRows > 0;
  } catch (error) {
    console.error('更新用户名失败:', error);
    throw error;
  }
};

// 验证用户密码
const verifyUserPassword = async (userId, password) => {
  try {
    const sql = `SELECT * FROM users WHERE id = ? AND password = ?`;
    const rows = await query(sql, [userId, password]);
    return rows.length > 0;
  } catch (error) {
    console.error('验证密码失败:', error);
    throw error;
  }
};

// 更改用户密码
const updatePassword = async (userId, newPassword) => {
  try {
    const sql = `UPDATE users SET password = ? WHERE id = ?`;
    const result = await query(sql, [newPassword, userId]);
    return result.affectedRows > 0;
  } catch (error) {
    console.error('更改密码失败:', error);
    throw error;
  }
};

// 获取用户的所有自定义智能体
const getUserAgents = async (userId) => {
  try {
    const sql = `SELECT * FROM agents WHERE user_id = ? ORDER BY created_at DESC`;
    const agents = await query(sql, [userId]);
    return agents.map(agent => {
      // 安全解析JSON，如果解析失败则返回空数组
      let tags = [];
      try {
        if (agent.tags) {
          tags = JSON.parse(agent.tags);
        }
      } catch (parseError) {
        console.error(`解析智能体ID ${agent.id} 的标签失败:`, parseError.message);
        console.log('无效的JSON字符串:', agent.tags);
        // 如果是字符串但格式不是JSON，尝试从字符串创建标签数组
        if (typeof agent.tags === 'string') {
          // 尝试将字符串分割成标签数组
          tags = agent.tags.split(',').map(tag => tag.trim()).filter(tag => tag);
          // 如果仍然无法获取有效标签，至少添加一个默认标签
          if (tags.length === 0) {
            tags = ['自定义'];
          }
          // 更新数据库中的无效JSON格式(异步执行，不影响当前查询)
          (async () => {
            try {
              const updateSql = `UPDATE agents SET tags = ? WHERE id = ?`;
              await query(updateSql, [JSON.stringify(tags), agent.id]);
              console.log(`已自动修复智能体 ${agent.id} 的标签格式`);
            } catch (updateError) {
              console.error('自动修复标签格式失败:', updateError);
            }
          })();
        }
      }
      
      // 返回处理后的智能体对象，确保使用驼峰命名规则的属性名
      return {
        ...agent,
        tags,
        isCustom: Boolean(agent.is_custom),
        // 将数据库中的下划线命名方式转换为前端使用的驼峰命名方式
        systemPrompt: agent.system_prompt || '',
        userId: agent.user_id
      };
    });
  } catch (error) {
    console.error('获取用户智能体失败:', error);
    return []; // 返回空数组而非抛出错误，确保应用可以继续运行
  }
};

// 保存自定义智能体
const saveUserAgent = async (agent) => {
  try {
    // 确保tags是有效的数组，并正确序列化为JSON
    let tagsToSave = [];
    if (Array.isArray(agent.tags)) {
      tagsToSave = agent.tags;
    } else if (typeof agent.tags === 'string') {
      // 如果传入的是字符串，尝试解析
      try {
        // 先尝试将其作为JSON解析
        tagsToSave = JSON.parse(agent.tags);
      } catch (parseError) {
        // 如果不是有效的JSON，视为逗号分隔的标签列表
        tagsToSave = agent.tags.split(',').map(tag => tag.trim()).filter(tag => tag);
      }
    }
    
    // 如果仍然不是数组或为空，使用默认标签
    if (!Array.isArray(tagsToSave) || tagsToSave.length === 0) {
      tagsToSave = ['自定义'];
    }
    
    // 获取要保存的system_prompt值，优先使用agent.systemPrompt（前端驼峰命名），
    // 如果不存在则尝试使用agent.system_prompt（数据库下划线命名）
    const systemPromptToSave = agent.systemPrompt !== undefined 
      ? agent.systemPrompt 
      : (agent.system_prompt || '');
    
    console.log('保存智能体，使用的系统提示词:', systemPromptToSave);
    
    const sql = `
      INSERT INTO agents 
      (id, user_id, name, description, system_prompt, icon, color, tags, category, is_custom) 
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
    `;
    const result = await query(sql, [
      agent.id,
      agent.userId,
      agent.name,
      agent.description || '',
      systemPromptToSave,
      agent.icon,
      agent.color,
      JSON.stringify(tagsToSave),
      agent.category,
      agent.isCustom
    ]);
    
    // 返回成功结果和处理后的数据
    return {
      success: result.affectedRows > 0,
      agent: {
        ...agent,
        tags: tagsToSave,
        systemPrompt: systemPromptToSave,
        system_prompt: systemPromptToSave // 同时包含两种形式，确保前后端都能正确处理
      }
    };
  } catch (error) {
    console.error('保存智能体失败:', error);
    throw error;
  }
};

// 更新自定义智能体
const updateUserAgent = async (agent) => {
  try {
    // 确保tags是有效的数组，并正确序列化为JSON
    let tagsToSave = [];
    if (Array.isArray(agent.tags)) {
      tagsToSave = agent.tags;
    } else if (typeof agent.tags === 'string') {
      // 如果传入的是字符串，尝试解析
      try {
        // 先尝试将其作为JSON解析
        tagsToSave = JSON.parse(agent.tags);
      } catch (parseError) {
        // 如果不是有效的JSON，视为逗号分隔的标签列表
        tagsToSave = agent.tags.split(',').map(tag => tag.trim()).filter(tag => tag);
      }
    }
    
    // 如果仍然不是数组或为空，使用默认标签
    if (!Array.isArray(tagsToSave) || tagsToSave.length === 0) {
      tagsToSave = ['自定义'];
    }
    
    // 获取要更新的system_prompt值，优先使用agent.systemPrompt（前端驼峰命名），
    // 如果不存在则尝试使用agent.system_prompt（数据库下划线命名）
    const systemPromptToSave = agent.systemPrompt !== undefined 
      ? agent.systemPrompt 
      : (agent.system_prompt || '');
      
    console.log('更新智能体，使用的系统提示词:', systemPromptToSave);
    
    const sql = `
      UPDATE agents 
      SET name = ?, description = ?, system_prompt = ?, icon = ?, 
          color = ?, tags = ?, category = ?
      WHERE id = ? AND user_id = ?
    `;
    const result = await query(sql, [
      agent.name,
      agent.description || '',
      systemPromptToSave,
      agent.icon,
      agent.color,
      JSON.stringify(tagsToSave),
      agent.category,
      agent.id,
      agent.userId
    ]);
    
    // 返回成功结果和处理后的数据
    return {
      success: result.affectedRows > 0,
      agent: {
        ...agent,
        tags: tagsToSave,
        systemPrompt: systemPromptToSave,
        system_prompt: systemPromptToSave // 同时包含两种形式，确保前后端都能正确处理
      }
    };
  } catch (error) {
    console.error('更新智能体失败:', error);
    throw error;
  }
};

// 删除自定义智能体
const deleteUserAgent = async (agentId, userId) => {
  try {
    const sql = `DELETE FROM agents WHERE id = ? AND user_id = ?`;
    const result = await query(sql, [agentId, userId]);
    return result.affectedRows > 0;
  } catch (error) {
    console.error('删除智能体失败:', error);
    throw error;
  }
};

// 获取用户收藏的智能体ID列表
const getUserFavoriteAgentIds = async (userId) => {
  try {
    // 首先确保表存在
    const checkTableSql = `
      CREATE TABLE IF NOT EXISTS favorite_agents (
        id INT PRIMARY KEY AUTO_INCREMENT,
        user_id INT NOT NULL,
        agent_id VARCHAR(100) NOT NULL,
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
        UNIQUE KEY unique_favorite (user_id, agent_id),
        FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
      )
    `;
    await query(checkTableSql);
    
    const sql = `SELECT agent_id FROM favorite_agents WHERE user_id = ?`;
    const favorites = await query(sql, [userId]);
    return favorites.map(fav => fav.agent_id);
  } catch (error) {
    console.error('获取用户收藏智能体ID失败:', error);
    // 在出错时返回空数组而不是抛出错误，确保应用可以继续运行
    return [];
  }
};

// 添加智能体到收藏
const addAgentToFavorites = async (userId, agentId) => {
  try {
    const sql = `INSERT INTO favorite_agents (user_id, agent_id) VALUES (?, ?) ON DUPLICATE KEY UPDATE created_at = CURRENT_TIMESTAMP`;
    const result = await query(sql, [userId, agentId]);
    return result.affectedRows > 0;
  } catch (error) {
    console.error('添加智能体到收藏失败:', error);
    throw error;
  }
};

// 从收藏中移除智能体
const removeAgentFromFavorites = async (userId, agentId) => {
  try {
    const sql = `DELETE FROM favorite_agents WHERE user_id = ? AND agent_id = ?`;
    const result = await query(sql, [userId, agentId]);
    return result.affectedRows > 0;
  } catch (error) {
    console.error('从收藏中删除智能体失败:', error);
    throw error;
  }
};

export {
  query,
  initDatabase,
  updateUsername,
  verifyUserPassword,
  updatePassword,
  getUserAgents,
  saveUserAgent,
  updateUserAgent,
  deleteUserAgent,
  getUserFavoriteAgentIds,
  addAgentToFavorites,
  removeAgentFromFavorites
}; 